package com.urbanflow.vinci.parcourt;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import com.urbanflow.vinci.controler.ArretManager;
import com.urbanflow.vinci.main.Arret;

public class Branche {
	private Branche parent;
	private List<Branche> sousBranche = new ArrayList<Branche>();
	private Arret noeud;
	private Integer poidCourant;
	private Boolean aGarder = false;
	
	public Branche(Arret unArret) {
		noeud = unArret;
	}
	
	
	public Branche(Arret unArret, Branche parent) {
		noeud = unArret;
		this.parent = parent;
	}
	
	public List<Branche> getSousBranche() {
		return sousBranche;
	}
	public void setSousBranche(List<Branche> sousBranche) {
		this.sousBranche = sousBranche;
	}
	public Arret getNoeud() {
		return noeud;
	}
	public void setNoeud(Arret noeud) {
		this.noeud = noeud;
	}
	public Branche getParent() {
		return parent;
	}
	public void setParent(Branche parent) {
		this.parent = parent;
	}
	
	public Integer calculerPoid(Arret terminus) {
		if(noeud == terminus) return 1;
		if(sousBranche == null || sousBranche.isEmpty()) {
			return null;
		}
		Integer meilleurPoidSousBranche = null;
		for(Branche brancheEnCours : sousBranche) {
			Integer poidBranche = brancheEnCours.calculerPoid(terminus);
			if(poidBranche != null) {
				if(meilleurPoidSousBranche == null || meilleurPoidSousBranche > poidBranche ) {
					meilleurPoidSousBranche = poidBranche;
				}
			}
		}
		if(meilleurPoidSousBranche == null) {
			return null;
		}
		return meilleurPoidSousBranche +1 ;
	}
	
	public List<Arret> construireRecursif(List<Arret> arretEncoreDisponible) {
		List<Arret> arretsPossible = ArretManager.getInstance().donnerlesArretsSuivant(noeud);
		List<Arret> arretsUtiliser = new ArrayList<Arret>();
		for(Arret unArret: arretsPossible) {
			if(arretEncoreDisponible.contains(unArret)) {
				arretEncoreDisponible.remove(unArret);
				Branche sousBranche = new Branche(unArret,this);
				arretsUtiliser.addAll(sousBranche.construireRecursif(arretEncoreDisponible));
			}
		}
		return arretsUtiliser;
	}
	
	public void ajouterSousBranche(Branche uneBranche) {
		sousBranche.add(uneBranche);
	}
	
	public Boolean possedeParcours(){
		return (sousBranche != null && !sousBranche.isEmpty());
	}

	public Integer calculerPoid() {
		return 0;
	}

	public Graphe construireParcours() {
		
		// TODO Auto-generated method stub
		return null;
	}
	
	public String toString(){
		StringBuffer sb = new StringBuffer();
		sb.append(noeud.toString()).append(" ").append(" \n");
		for(Branche uneBranche : sousBranche) {
			sb.append(uneBranche.toString()).append("");
		}
		return sb.toString();
	}


	public Integer supprimerSuperflue() {
		if(aGarder)
			return 1;
		Integer poidLeger = null;
		Iterator<Branche> it = sousBranche.iterator();
		while(it.hasNext()) {
			Branche uneBranche = it.next();
			Integer poidBranche = uneBranche.supprimerSuperflue();
			if(poidBranche == null || ( poidLeger != null && poidBranche > poidLeger)) {
				it.remove();
			} else {
				poidLeger = poidBranche;
			}
		}
		if(sousBranche.isEmpty()) {
			return null;
		}
		poidCourant = poidLeger + 1;
		return poidCourant;
	}


	public Boolean getaGarder() {
		return aGarder;
	}


	public void setaGarder(Boolean aGarder) {
		this.aGarder = aGarder;
	}
	
}
